The overall user experience of a device may be affected when the performance of one or more processes running on the device are hindered due to the availability of memory resources. Accordingly, software developers are often cognizant of managing memory resources when developing applications, and thus, often take advantage of the many available memory debugging tools. Depending on the development environment, these debugging tools often provide information for heap memory allocations based on a stack trace (or stack backtrace, or stack traceback). For example, a stack trace may include information of stack frames at a certain point in time during the execution of a program. Tools that merely rely on the stack trace, however, are often tedious to use, and accordingly, not always developer friendly with respect to analyzing heap memory allocations.
For example, current tools minimally process the stack trace information before displaying it to the user. Accordingly, traditional tools often require a developer to analyze a large number of lines of text or manage complicated relationship representations. Moreover, heap memory allocations are often a result of various interrelated programs (or processes) that are not easily traceable from a mere unprocessed listing (or “dump”) of a stack trace. Accordingly, when tracking memory usage for these interrelated programs, for example, between application builds, it is often difficult to attribute variances of memory usage to a particular source. Thus, traditional memory analysis tools are often ill-suited for analyzing memory usage during coordinated or complex software development efforts.